package IOLearn;



import org.junit.jupiter.api.Test;

import java.io.*;

/**
 * @author Lenl
 * @version v1.0
 * @create 2021-06-05 22:05
 * @description
 *
 * 一、流的分类
 * 1.操作数据单位：字节流、字符流
 * 2.数据的流向：输入流、输出流
 * 3.流的角色：节点流、处理流
 * 二、流的体系结构
 * 抽象基类             节点流               缓冲流(处理流的一种)
 * InputStream       FileInputStream        Buffered...
 * OutputStream      FileOutputStream       Buffered...
 * Reader            FileReader             Buffered...
 * Writer            FileWriter             Buffered...
 *
 *
 *
 */
public class FileReaderWriterTest {
    /**
     *
     * 将hello.txt的文本读出来，并输出到控制台
     */
    @Test
    public void testFileReader(){
        //相较于当前module
        //1.实例化File类的对象，指明要操作的文件
        File file=new File("hello.txt");
        FileReader fr=null;
        try {
        //2.提供具体的流
        fr=new FileReader(file);
        //3.数据的读入
        //read()返回读入的字符，如果达到末尾，返回-1
        //异常处理：为保证流资源的关闭，需要使用tey-catch-finally
        //读入的文件一定要存在，否则会报FileNotFoundException

        //方式一：
//        int data=fr.read();
//        while(data!=-1){
//            System.out.print((char)data);
//            data=fr.read();
//        }
        //方式二：

            int data;
            while((data= fr.read())!=-1){
                System.out.print((char)data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.流的关闭操作
            try {
                if(fr!=null)
                fr.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    @Test
    public void testFileReader1(){
        FileReader fr=null;
        try {
            //1.File类的实例化
            File file=new File("hello.txt");
            //2.FileReader流的实例化
            fr=new FileReader(file);
            //3.读入的操作
            //每次读入数组中个数为len，如果达到文件末尾，返回-1
            char[] cbuf=new char[5];
            int len;
            while((len=fr.read(cbuf))!=-1){
                //方式一：
//                for (int i=0;i<len;i++){
//                    System.out.print(cbuf[i]);
//                }
                //方式二：
                String str=new String(cbuf,0,len);
                System.out.print(str);
            }

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.资源的关闭
            if(fr!=null) {
                try {
                    fr.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }


    }

    /**
     * 说明
     * 1.输出操作：对应File不存在会自动创建此文件
     *           如果存在，默认覆盖已存在文件，append为true则在源文件后追加
     *
     *
     */
    @Test
    public void testFileWriter(){
        FileWriter fw=null;
        try {
            //1.根据File类的对象，指明写出的文件
            File file=new File("hello1.txt");
            //2.提供FileWriter的对象，用于数据的写出
            fw=new FileWriter(file,true);
            //3.写出的操作
            fw.write("I have a dream!\n");
            fw.write("You need to have a dream too!");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.关闭流资源
            try {
                fw.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    @Test
    public  void testFileReaderFileWriter(){
        FileReader fr=null;
        FileWriter fw=null;

        try {
            //1.创建File类对象指定读入和写出的文件
            File fread=new File("hello1.txt");
            File fwrite=new File("hello.txt");
            //2.创建输入流和输出流对象
            fr=new FileReader(fread);
            fw=new FileWriter(fwrite,true);
            int len;
            char[] buffer=new char[10];
            while ((len=fr.read(buffer))!=-1){
                fw.write(buffer,0,len);
            }
            //3.数据的读入和写出操作
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //4.关闭流资源
            try {
                if(fr!=null)
                fr.close();
            }catch (IOException e) {
                e.printStackTrace();
            }
            if(fw!=null) {
                try {
                    fw.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }


    }
}
